home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / oper_sys / oasis / oasis1-1.lha / oasis-1.1 / scan.c < prev    next >
C/C++ Source or Header  |  1992-05-01  |  10KB  |  244 lines
  1. /*==========================================================================*
  2.     Oasis Alpha Version 1.1               (C) Copyright 1992 Fah-Chun Cheong
  3.     Revised: 5/1/92 by: fcc@eecs.umich.edu    and The University of Michigan
  4.     ------------------------------------------------------------------------
  5.     Permission to use, copy, modify, distribute, sell and resell Oasis Alpha
  6.     software and its documentation for any purpose and without fee is hereby
  7.     granted, provided that the authorship be appropriately credited and
  8.     acknowledged, and that the above copyright notice appear in all copies
  9.     and both the copyright notice and this permission notice appear in
  10.     supporting documentation. The author makes no representations about the
  11.     suitability of this software for any purpose. It is provided "as is"
  12.     without express or implied warranty. Oasis Alpha is free, caveat emptor!
  13.     ------------------------------------------------------------------------
  14.     To request Oasis Alpha source code:   oasis-alpha-request@eecs.umich.edu
  15.     To enroll in the mailing list:        oasis-alpha-request@eecs.umich.edu
  16.     To send bug reports:                  oasis-alpha-bugs@eecs.umich.edu
  17.     To discuss openly all matters Oasis:  oasis-alpha@eecs.umich.edu
  18.  *==========================================================================*/
  19. #include                <sys/types.h>
  20. #include                "gener.h"
  21. #include                "gen.h"
  22.  
  23. #define E_LEX_CHAR      "Missing right single quote (') in character '%c'.\n"
  24. #define E_LEX_STRING    "Missing right double quote (\") in string \"%s\".\n"
  25. #define E_LEX_TOKEN     "Bad token (ascii = %d) discarded.\n"
  26.  
  27. #define err1(s,a)       fprintf(stderr, s, a)
  28.  
  29. extern  u_long          getaddr();
  30.  
  31. static  char           *ptr;
  32. static  char           *str;
  33.  
  34. static  int ascii[] = {
  35.         1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  36.         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  37.         0,  1, 19, 15, 11,  1, 13, 18,  1,  1,  1,  1,  1,  1,  2,  1,
  38.        17, 17, 17, 17, 17, 17, 17, 17, 17, 17,  4,  1,  7,  6,  8,  3,
  39.  
  40.        16, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
  41.        10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,  1,  0,  1,  0, 10,
  42.        14,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
  43.         9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  1,  5,  1, 12,  0
  44. };
  45.  
  46.  
  47. void    scan_escape()
  48. {
  49.         switch (*++ptr) {
  50.             case 'n':   *ptr = '\n'; break;
  51.             case 't':   *ptr = '\t'; break;
  52.             case 'b':   *ptr = '\b'; break;
  53.             case 'r':   *ptr = '\r'; break;
  54.             case 'f':   *ptr = '\f'; break;
  55.             default:    if (isdigit(*ptr)) {
  56.                             char *ptr0 = ptr;
  57.                             do  ptr++;
  58.                             while (isdigit(*ptr));
  59.                             *--ptr = (char) atoi(ptr0);
  60.                         }
  61.         }
  62. }
  63.  
  64. int     scan_token()
  65. {
  66. AGAIN:  while (isspace(*ptr))
  67.             ptr++;
  68.  
  69.         switch (ascii[*ptr]) {
  70.             case 1:     return *ptr++;
  71.  
  72.             case 2:     if (isspace(ptr[-1]) || isspace(ptr[1]))
  73.                             return *ptr++;
  74.                         ptr++;
  75.                         return DOT;
  76.  
  77.             case 3:     switch (*++ptr) {
  78.                             case '-':   ptr++;  return DO;
  79.                             default:    return  '?';
  80.                         }
  81.  
  82.             case 4:     switch (*++ptr) {
  83.                             case ':':   ptr++;  return ISA;
  84.                             case '-':   ptr++;  return IF;
  85.                             case 'c':   ptr++;  return C;
  86.                             case 'i':   ptr++;  return I;
  87.                             case 'f':   ptr++;  return F;
  88.                             case 'o':   ptr++;  return O;
  89.                             case 'a':   ptr++;  return A;
  90.                             case 'y':   ptr++;  return Y;
  91.                             case 'l':   ptr++;  return L;
  92.                             case '$':   zzlval.i = atoi(++ptr);
  93.                                         while (isdigit(*ptr))
  94.                                             ptr++;
  95.                                         return  G;
  96.                             default:    return  ':';
  97.                         }
  98.  
  99.             case 5:     switch (*++ptr) {
  100.                             case '-':   ptr++;  return THEN;
  101.                             default:    return  '|';
  102.                         }
  103.  
  104.             case 6:     switch (*++ptr) {
  105.                             case '>':   ptr++;  return RETURN;
  106.                             case '=':   ptr++;  return EQ;
  107.                             default:    return  '=';
  108.                         }
  109.  
  110.             case 7:     switch (*++ptr) {
  111.                             case '>':   ptr++;  return NE;
  112.                             case '=':   ptr++;  return LE;
  113.                             default:    return  LT;
  114.                         }
  115.  
  116.             case 8:     switch (*++ptr) {
  117.                             case '=':   ptr++;  return GE;
  118.                             default:    return  GT;
  119.                         }
  120.  
  121.             case 9:     zzlval.s = str;
  122.                         do  *str++ = *ptr++;
  123.                         while (isalnum(*ptr) || *ptr == '_');
  124.                         *str++ = '\0';
  125.                         return ID;
  126.  
  127.             case 10:    zzlval.s = str;
  128.                         do  *str++ = *ptr++;
  129.                         while (isalnum(*ptr) || *ptr == '_');
  130.                         *str++ = '\0';
  131.                         return strcmp(zzlval.s, "_") ? CID : '_';
  132.  
  133.             case 11:    zzlval.s = str;
  134.                         for (ptr++; isalpha(*ptr);)
  135.                             *str++ = *ptr++;
  136.                         *str++ = '\0';
  137.                         return !strcmp(zzlval.s, "nil")  ? NIL
  138.                              : !strcmp(zzlval.s, "true") ? TRUE
  139.                              : !strcmp(zzlval.s, "fail") ? FAIL
  140.                              : !strcmp(zzlval.s, "wait") ? WAIT
  141.                              : !strcmp(zzlval.s, "post") ? POST : '$';
  142.  
  143.             case 12:    zzlval.i = atoi(++ptr);
  144.                         while (isdigit(*ptr)) ptr++;
  145.                         return VID;
  146.  
  147.             case 13:    zzlval.i = atoi(++ptr);
  148.                         while (isdigit(*ptr)) ptr++;
  149.                         return MID;
  150.  
  151.             case 14:    zzlval.i = atoi(++ptr);
  152.                         while (isdigit(*ptr)) ptr++;
  153.                         return GID;
  154.  
  155.             case 15:    zzlval.i = atoi(++ptr);
  156.                         ptr++;
  157.                         while (isdigit(*ptr)) ptr++;
  158.                         return LID;
  159.  
  160.             case 16:    zzlval.s = str;
  161.                         while (isspace(*++ptr)) ;
  162.  
  163.                         if (isdigit(*ptr))
  164.                             do  do *str++ = *ptr++;
  165.                                 while (isdigit(*ptr));
  166.                             while (*ptr == '.' && isdigit(ptr[1]));
  167.                         else if (isalpha(*ptr))
  168.                             do  do *str++ = *ptr++;
  169.                                 while (isalnum(*ptr));
  170.                             while (*ptr == '.' && isalpha(ptr[1]));
  171.  
  172.                         *str++ = '\0';
  173.                         zzlval.i = getaddr(zzlval.s);
  174.                         return ATINET;
  175.  
  176.             case 17:    zzlval.s = ptr;
  177.                         while (isdigit(*++ptr)) ;
  178.                         if (*ptr == '.' && isdigit(ptr[1])) {
  179.                             while (isdigit(*++ptr)) ;
  180.                             if (*ptr == 'e' || *ptr == 'E') {
  181.                     EXPO:       if (ptr[1] == '-') ptr++;
  182.                                 while (isdigit(*++ptr)) ;
  183.                             }
  184.                             zzlval.f = atof(zzlval.s);
  185.                             return FLOAT;
  186.                         }
  187.                         if (*ptr == 'e' || *ptr == 'E')
  188.                             goto EXPO;
  189.                         zzlval.i = atoi(zzlval.s);
  190.                         return INTEGER;
  191.  
  192.             case 18:    if (ptr[-1] == '-' || ptr[-1] == '/' || ptr[-1] == '%')
  193.                             return *ptr++;
  194.                         if (*++ptr == '\\')
  195.                             scan_escape();
  196.                         zzlval.c = *ptr++;
  197.                         if (*ptr++ != '\'')
  198.                             err1(E_LEX_CHAR, ptr[-2]);
  199.                         return CHARACTER;
  200.  
  201.             case 19:    zzlval.s = str;
  202.                         ptr++;
  203.                         while (*ptr != '"' && *ptr != '\n') {
  204.                             if (*ptr == '\\')
  205.                                 scan_escape();
  206.                             *str++ = *ptr++;
  207.                         }
  208.                         *str++ = '\0';
  209.                         if (*ptr++ != '"')
  210.                             err1(E_LEX_STRING, zzlval.s);
  211.                         return STRING;
  212.  
  213.             default:    err1(E_LEX_TOKEN, *ptr++);
  214.                         goto AGAIN;
  215.         }
  216. }
  217.  
  218. void    zzerror()
  219. {
  220.         extern int zzchar;
  221.  
  222.         if (isprint(zzchar))
  223.             err1("Bad syntax '%c'.\n", zzchar);
  224.         else err1("Bad syntax (token code = %d).\n", zzchar);
  225. }
  226.  
  227. int     zzlex()
  228. {
  229.         int token = scan_token();
  230.  
  231. #ifdef  SCAN_BUG
  232.         fprintf(stderr, "token code = %3d %c\n", token, isprint(token) ? token : ' ');
  233. #endif  SCAN_BUG
  234.         return token;
  235. }
  236.  
  237. void    init_scan(buf)
  238. char   *buf;
  239. {
  240.         str = buf;
  241.         ptr = buf;
  242. }
  243.  
  244.